package jzlb

import (
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

)

// []any 或者 map[string]any
func q_切片和map置值(原始数据 any, 键组路径 []string, 值 any) (返回_错误 error) {
	新值, err := q_切片和map深拷贝(值)
	if err != nil {
		switch 当前值 := 原始数据.(type) {
		case []any:
			_, 返回_错误 = 切片和map置值(当前值, 键组路径, 值)
			return
		case map[string]any:
			_, 返回_错误 = 切片和map置值(当前值, 键组路径, 值)
			return
		default:
			返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
			return
		}
	}
	switch 当前值 := 原始数据.(type) {
	case []any:
		_, 返回_错误 = 切片和map置值(当前值, 键组路径, 新值)
		return
	case map[string]any:
		_, 返回_错误 = 切片和map置值(当前值, 键组路径, 新值)
		return
	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}

func 切片和map置值(原始数据 any, 键组路径 []string, 值 any) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		返回_错误 = errors.New("键组路径不能为空")
		return
	}
	if lenKeys == 1 {
		switch 当前值 := 原始数据.(type) {
		case map[string]any:
			当前值[键组路径[0]] = 值
			返回_值 = 当前值
			return
		case []any:
			位置, 错误 := strconv.Atoi(键组路径[0])

			if 位置 > len(当前值)-1 {
				返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
				return
			}
			if 位置 < 0 {
				返回_错误 = errors.New("路径错误:切片置值不能<0")
				return
			}
			if 错误 != nil {
				返回_错误 = errors.New("切片路径错误:" + 错误.Error())
				return
			}
			switch 新值 := 值.(type) {
			case map[string]any:
				当前值[位置] = 新值
				返回_值 = 当前值
				return

			default:
				当前值[位置] = 新值
			}

			//当前值[位置] = 值
			返回_值 = 当前值
			return
		default:
			添加值 := make(map[string]any)
			添加值[键组路径[0]] = 值
			返回_值 = 添加值
			return

		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:
		当前值[键组路径[0]], 返回_错误 = 切片和map置值(当前值[键组路径[0]], 键组路径[1:], 值)
		return 当前值, 返回_错误
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(原始数据.([]any)) {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 错误 != nil {
			返回_错误 = errors.New("切片路径错误:" + 错误.Error())
			return
		}
		当前值[位置], 返回_错误 = 切片和map置值(当前值[位置], 键组路径[1:], 值)
		return 当前值, 返回_错误

	default:

		添加值 := make(map[string]any)
		添加值[键组路径[0]] = 键组路径[1]
		当前值 = 添加值
		当前值.(map[string]any)[键组路径[0]], 返回_错误 = 切片和map置值(添加值[键组路径[0]], 键组路径[1:], 值)
		return 当前值, 返回_错误
	}

}

func q_切片和map子切片添加值(原始数据 any, 键组路径 []string, 值 any) (返回_错误 error) {
	新值, err := q_切片和map深拷贝(值)
	if err != nil {
		switch 当前值 := 原始数据.(type) {
		case []any:
			_, 返回_错误 = 切片和map子切片添加值(当前值, 键组路径, 值)
			return
		case map[string]any:
			_, 返回_错误 = 切片和map子切片添加值(当前值, 键组路径, 值)
			return
		default:
			返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
			return
		}
	}
	switch 当前值 := 原始数据.(type) {
	case []any:
		_, 返回_错误 = 切片和map子切片添加值(当前值, 键组路径, 新值)
		return
	case map[string]any:
		_, 返回_错误 = 切片和map子切片添加值(当前值, 键组路径, 新值)
		return
	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}
func 切片和map子切片添加值(原始数据 any, 键组路径 []string, 值 any) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		switch 当前值 := 原始数据.(type) {
		case []any:
			当前值 = append(当前值, 值)
			返回_值 = 当前值
			return
		default:
			返回_错误 = errors.New("错误:键路径  不存在 或者 不为[]any")
			return
		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:
		当前值[键组路径[0]], 返回_错误 = 切片和map子切片添加值(当前值[键组路径[0]], 键组路径[1:], 值)
		return 当前值, 返回_错误
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(原始数据.([]any)) {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 错误 != nil {
			返回_错误 = errors.New("切片路径错误:" + 错误.Error())
			return
		}
		当前值[位置], 返回_错误 = 切片和map子切片添加值(当前值[位置], 键组路径[1:], 值)
		return 当前值, 返回_错误
	default:

		返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在 或者 不为[]any | map[string]any")
		return 当前值, 返回_错误
	}

}

// []any 或者 map[string]any
func q_切片和map取值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {
	switch 当前值 := 原始数据.(type) {
	case []any:
		返回_值, 返回_错误 = 切片和map取值(当前值, 键组路径)

	case map[string]any:
		返回_值, 返回_错误 = 切片和map取值(当前值, 键组路径)

	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}
	值, err := q_切片和map深拷贝(返回_值)
	if err != nil {
		return
	}
	返回_值 = 值
	return

}

func 切片和map取值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		返回_错误 = errors.New("路径错误:路径长度不能为0")
		return
	}
	if lenKeys == 1 {
		switch 当前值 := 原始数据.(type) {
		case map[string]any:
			值, ok := 当前值[键组路径[0]]
			if ok {
				返回_值 = 值
			} else {
				返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			}

			return
		case []any:
			位置, 错误 := strconv.Atoi(键组路径[0])

			if 位置 > len(当前值)-1 {
				返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
				return
			}
			if 位置 < 0 {
				返回_错误 = errors.New("路径错误:切片置值不能<0")
				return
			}
			if 错误 != nil {
				返回_错误 = errors.New("路径错误:" + 错误.Error())
				return
			}
			返回_值 = 当前值[位置]
			return
		default:
			返回_错误 = errors.New("路径错误:非有效路径")
			return

		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:

		值, ok := 当前值[键组路径[0]]
		if !ok {
			返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			return
		}
		返回_值, 返回_错误 = 切片和map取值(值, 键组路径[1:])
		return
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(当前值)-1 {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 位置 < 0 {
			返回_错误 = errors.New("路径错误:切片置值不能<0")
			return
		}

		if 错误 != nil {
			返回_错误 = errors.New("路径错误:" + 错误.Error())
			return
		}
		返回_值, 返回_错误 = 切片和map取值(当前值[位置], 键组路径[1:])
		return
	default:
		返回_错误 = errors.New("路径错误:非有效路径")
		return
	}

}

// []any 或者 map[string]any
func q_切片和map删除值(原始数据 any, 键组路径 []string) (返回_值 any,返回_错误 error) {
	
	switch 当前值 := 原始数据.(type) {
	case []any:
		返回_值, 返回_错误 = 切片和map删除值(当前值, 键组路径)
		return
	case map[string]any:
		返回_值, 返回_错误 = 切片和map删除值(当前值, 键组路径)
		return
	default:
		返回_值=原始数据
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}
func 切片和map删除值(原始数据 any, 键组路径 []string) (返回_值 any, 返回_错误 error) {
	lenKeys := len(键组路径)
	if lenKeys == 0 {
		返回_错误 = errors.New("路径错误:路径长度不能为0")
		return
	}
	if lenKeys == 1 {
		switch 当前值 := 原始数据.(type) {
		case map[string]any:
			_, ok := 当前值[键组路径[0]]
			if ok {
				delete(当前值, 键组路径[0])
				返回_值 = 当前值
			} else {
				返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			}
			return
		case []any:
			位置, 错误 := strconv.Atoi(键组路径[0])
			if 位置 > len(当前值)-1 {
				返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
				return
			}
			if 位置 < 0 {
				返回_错误 = errors.New("路径错误:切片置值不能<0")
				return
			}

			if 错误 != nil {
				返回_错误 = errors.New("路径错误:" + 错误.Error())
				return
			}
			fmt.Println(len(当前值[:位置]))
			fmt.Println(len(当前值[位置+1:]))
			if len(当前值)==1{
				返回_值 = 当前值[:位置]
				return
			}else if len(当前值[:位置])==0 && len(当前值[位置+1:])!=0{
				返回_值 = 当前值[位置+1:]
				return
			}else if len(当前值[:位置])!=0 && len(当前值[位置+1:])==0{
				返回_值 = 当前值[:位置]
				return
			}else{
				当前值 = append(当前值[:位置], 当前值[位置+1:])
				返回_值 = 当前值
			}
			return
		default:
			返回_错误 = errors.New("路径错误:非有效路径")
			return

		}
	}
	switch 当前值 := 原始数据.(type) {
	case map[string]any:
		值, ok := 当前值[键组路径[0]]
		if !ok {
			返回_错误 = errors.New("错误:键路径 '" + 键组路径[0] + "' 不存在")
			return
		}
		返回_值, 返回_错误 = 切片和map删除值(值, 键组路径[1:])
		return
	case []any:
		位置, 错误 := strconv.Atoi(键组路径[0])
		if 位置 > len(当前值)-1 {
			返回_错误 = errors.New("路径错误:切片置值位置超过切片长度")
			return
		}
		if 位置 < 0 {
			返回_错误 = errors.New("路径错误:切片置值不能<0")
			return
		}
		if 错误 != nil {
			返回_错误 = errors.New("路径错误:" + 错误.Error())
			return
		}
		返回_值, 返回_错误 = 切片和map删除值(当前值[位置], 键组路径[1:])
		return
	default:
		返回_错误 = errors.New("路径错误:非有效路径")
		return
	}

}

// []any 或者 map[string]any  另外[]map[string]any 会 自动变为 []any
func q_切片和map深拷贝(原始数据 any) (返回_值 any, 返回_错误 error) {
	switch 当前值 := 原始数据.(type) {
	case []any:
		返回_值 = 切片和map深拷贝(当前值)
		return
	case map[string]any:
		返回_值 = 切片和map深拷贝(当前值)
		return
	case []map[string]any:
		转换值 := make([]any, len(当前值))
		for i, v := range 当前值 {
			转换值[i] = v
		}
		返回_值 = 切片和map深拷贝(转换值)
		return
	default:
		返回_错误 = errors.New("只支持 []any 或者 map[string]any 当前数据类型错误")
		return
	}

}

func 切片和map深拷贝(原始数据 any) (返回_值 any) {
	if 条件map, ok := 原始数据.(map[string]any); ok {
		新map := make(map[string]any)
		for k, v := range 条件map {
			新map[k] = 切片和map深拷贝(v)
		}
		返回_值 = 新map
		return
	} else if 条件切片, ok := 原始数据.([]any); ok {
		新切片 := make([]any, len(条件切片))
		for k, v := range 条件切片 {
			新切片[k] = 切片和map深拷贝(v)
		}
		返回_值 = 新切片
		return
	}
	返回_值 = 原始数据
	return
}

func 切片和map深拷贝json前byte组处理(原始数据 any) (返回_值 any) {
	if 条件map, ok := 原始数据.(map[string]any); ok {
		新map := make(map[string]any)
		for k, v := range 条件map {
			switch 当前值 := v.(type) {
			case time.Time:
				新map[k] = 切片和map深拷贝json前byte组处理(当前值.Format("2006-01-02 15:04:05"))
			case []byte:
				新map[k] = 切片和map深拷贝json前byte组处理(string(当前值))

			default:
				新map[k] = 切片和map深拷贝json前byte组处理(v)

			}
		}
		返回_值 = 新map
		return
	} else if 条件切片, ok := 原始数据.([]any); ok {
		新切片 := make([]any, len(条件切片))
		for k, v := range 条件切片 {
			switch 当前值 := v.(type) {
			case time.Time:
				新切片[k] = 切片和map深拷贝json前byte组处理(当前值.Format("2006-01-02 15:04:05"))
			case []byte:
				新切片[k] = 切片和map深拷贝json前byte组处理(string(当前值))

			default:
				新切片[k] = 切片和map深拷贝json前byte组处理(v)

			}
		}
		返回_值 = 新切片
		return
	}
	返回_值 = 原始数据
	return
}

func 切片和map值类型筛选(原始数据 any) (返回_错误 error) {
	switch 当前值 := 原始数据.(type) {
	case string:
		return
	case int:
		return
	case bool:
		return
	case byte:
		return
	case nil:
		return
	case float64:
		return
	case float32:
		return
	case int8:
		return
	case int16:
		return
	case int32:
		return
	case int64:
		return
	case uint:
		return
	case uint16:
		return
	case uint32:
		return
	case uint64:
		return
	case []byte:
		return
	case time.Time:
		return
	case []map[string]any:
		for _, v := range 当前值 {
			返回_错误 = 切片和map值类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}
		return
	case map[string]any:
		for _, v := range 当前值 {
			返回_错误 = 切片和map值类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}
		return
	case []any:
		for _, v := range 当前值 {
			返回_错误 = 切片和map值类型筛选(v)
			if 返回_错误 != nil {
				return
			}
		}
		return
	default:
		返回_错误 = fmt.Errorf("错误: 类型 %T 不是支持的基本类型", 当前值)
		return
	}

}

// 用 . 分割 但 不分割 ' ' 和 "" 内的 . 自动去除 前后包裹的 []
func q_切片和map路径分割(路径 string) (返回_值 []string) {
	返回_值 = 切片和map路径分割(路径, ".", false)
	for i, v := range 返回_值 {
		if len(v) >= 3 && strings.HasPrefix(v, "[") && strings.HasSuffix(v, "]") {
			返回_值[i] = v[1 : len(v)-1]
		}
	}
	return
}

func 切片和map路径分割(路径 string, sep string, 保持符号 bool) (返回_值 []string) {
	//sep := "."
	separator := sep
	keepQuotes := 保持符号
	singleQuoteOpen := false
	doubleQuoteOpen := false
	var tokenBuffer []string
	var ret []string

	arr := strings.Split(路径, "")
	for _, element := range arr {
		matches := false
		if separator == element {
			matches = true
		}

		if element == "'" && !doubleQuoteOpen {
			if keepQuotes {
				tokenBuffer = append(tokenBuffer, element)
			}
			singleQuoteOpen = !singleQuoteOpen
			continue
		} else if element == `"` && !singleQuoteOpen {
			if keepQuotes {
				tokenBuffer = append(tokenBuffer, element)
			}
			doubleQuoteOpen = !doubleQuoteOpen
			continue
		}

		if !singleQuoteOpen && !doubleQuoteOpen && matches {
			if len(tokenBuffer) > 0 {
				ret = append(ret, strings.Join(tokenBuffer, ""))
				tokenBuffer = make([]string, 0)
			} else if sep != "" {
				ret = append(ret, element)
			}
		} else {
			tokenBuffer = append(tokenBuffer, element)
		}
	}
	if len(tokenBuffer) > 0 {
		ret = append(ret, strings.Join(tokenBuffer, ""))
	} else if sep != "" {
		ret = append(ret, "")
	}
	return ret
}

func any_到文本(任意数据 any) (返回_值 string) {
	if 任意数据 == nil {
		return
	}
	switch 当前值 := 任意数据.(type) {
	case string:
		返回_值 = 当前值
		return
	case time.Time:
		返回_值 = 当前值.Format("2006-01-02 15:04:05")
		return
	case map[string]any:
		转换表 := 切片和map深拷贝json前byte组处理(当前值)
		JSON, err := json.Marshal(转换表)
		if err != nil {
			返回_值 = "{}"
			return
		}
		返回_值 = string(JSON)
		return
	case []any:
		转换表 := 切片和map深拷贝json前byte组处理(当前值)
		JSON, err := json.Marshal(转换表)
		if err != nil {
			返回_值 = "[]"
			return
		}
		返回_值 = string(JSON)
		return
	case []byte:
		返回_值 = string(当前值)
		return
	default:
		返回_值 = fmt.Sprintf("%v", 任意数据)
		return
	}
}
